package com.lb.bigdata.spark.core

object Test {
    def main(args: Array[String]): Unit = {
        test1()
        var arr = Array(3, -2, 0, 9, 5, 7, 4, 6, 1)
        arr = test2(arr)
        println(arr.toList)
        println(s"查找元素的位置为${test3(arr, -2)}")
        //test4()
    }

    /**
     * 1. "   adbc  "，去除这个字符串前后两侧的空格
     */
    def test1(): Unit = {
        val str = "   adbc  "
        val ret = str.dropWhile(_ == ' ').reverse.dropWhile(_ == ' ').reverse
        println(ret)
    }

    /**
     * 2.使用scala或者java对如下集合进行快速排序，使得几何元素升序排序。
     */
    def test2(arr: Array[Int]): Array[Int] = {

        if(arr.isEmpty) {
            arr
        } else {
            val (left, right) = arr.tail.partition(_ < arr.head)
            (test2(left).:+(arr.head)).++(test2(right))
        }
    }

    /**
     * 3. 针对上述快速排序的结果，编写一个非递归的二分查找，
     * 查找指定的元素在集合中的索引位置。
     * List(-2, 0, 1, 3, 4, 5, 6, 7, 9)
     */
    def test3(arr: Array[Int], n: Int):Int = {
        var start = 0
        var end = arr.length - 1
        var middle = (start + end) / 2
        while(start <= end) {
            middle = (start + end) / 2
            if(n == arr(middle)) {
                return middle
            }else if(n < arr(middle)) {
                end = middle - 1
            }else {
                start = middle + 1
            }
        }
        -1
    }

    /**
     * 4. 计算字符串"agbvadfadef"中每一个字符出现的次数，
     * 其次按照次数降序排序，如果次数相等，按照字符升序排序。
     */
    def test4(): Unit = {
        val str = "agbvadfadef"
        str.groupBy(word => word)
                .map{case(word, str) => {(word, str.length)}}
                .toList
                .sorted(new Ordering[(Char, Int)](){
                    override def compare(x: (Char, Int), y: (Char, Int)): Int = {
                        var ret = y._2.compareTo(x._2)
                        if(ret == 0) {
                            ret = x._1.compareTo(y._1)
                        }
                        ret
                    }
                }).foreach(println)
    }
}
